home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DBio / DSeqPrint.cpp < prev    next >
Encoding:
Text File  |  1996-07-05  |  54.0 KB  |  2,004 lines  |  [TEXT/R*ch]
  1. // DSeqPrint.cpp
  2. // d.g.gilbert, 1991-95
  3.  
  4. #define MASKS 1
  5.  
  6. #include "DSequence.h"
  7. #include "DSeqList.h"
  8. #include "DSeqDoc.h"
  9. #include "DSeqPrint.h"
  10. #include "DSeqPrintSubs.h"
  11. #include "DREnzyme.h"
  12.  
  13. #include <ncbi.h>
  14. #include <dgg.h>
  15. #include <Dvibrant.h>
  16. #include <DControl.h>
  17. #include <DDialogText.h>
  18. #include <DWindow.h>
  19. #include <DTableView.h>
  20. #include <DApplication.h>
  21. #include <DTask.h>
  22. #include <DTracker.h>
  23. #include <DMenu.h>
  24. #include <DUtil.h>
  25.  
  26.  
  27.  
  28. #undef TESTZOOM
  29.  
  30.  
  31.  
  32. Global DSeqPrintPrefs* gSeqPrintPrefs = NULL;
  33.  
  34. char* DSeqPrintPrefs::gNameFontName = (char*) "times";
  35. char* DSeqPrintPrefs::gBaseFontName = (char*) "courier";
  36. char* DSeqPrintPrefs::gIndexFontName = (char*) "times";
  37. Nlm_FonT 
  38.             DSeqPrintPrefs::gNameFont = NULL, 
  39.              DSeqPrintPrefs::gBaseFont = NULL, 
  40.           DSeqPrintPrefs::gIndexFont = NULL;
  41. short 
  42.             DSeqPrintPrefs::gNameFontSize = 10, 
  43.             DSeqPrintPrefs::gBaseFontSize = 10, 
  44.             DSeqPrintPrefs::gIndexFontSize = 9,
  45.             DSeqPrintPrefs::gNameStyle = 0,  
  46.             DSeqPrintPrefs::gBaseStyle = 0,  
  47.             DSeqPrintPrefs::gIndexStyle = 0;
  48. Boolean     
  49.             DSeqPrintPrefs::gNameLeft = false,
  50.             DSeqPrintPrefs::gNameRight = true,
  51.             DSeqPrintPrefs::gIndexLeft = true,
  52.             DSeqPrintPrefs::gIndexRight = false,
  53.             DSeqPrintPrefs::gIndexTop = true, 
  54.             DSeqPrintPrefs::gColored = true;
  55.  
  56.     // restmap prefs ..
  57. Boolean  
  58.             DSeqPrintPrefs::gShowComplement = true,
  59.             DSeqPrintPrefs::gThreeLetAA = false,
  60.             DSeqPrintPrefs::gOnlyORF = false,
  61.             DSeqPrintPrefs::gShowAA1 = false,
  62.             DSeqPrintPrefs::gShowAA2 = false,
  63.             DSeqPrintPrefs::gShowAA3 = false,
  64.             DSeqPrintPrefs::gShowCompAA1 = false,
  65.             DSeqPrintPrefs::gShowCompAA2 = false,
  66.             DSeqPrintPrefs::gShowCompAA3 = false,
  67.             DSeqPrintPrefs::gShowAllZymes = false,
  68.             DSeqPrintPrefs::gShowCutpoints = false,
  69.             DSeqPrintPrefs::gShowExcludedCutters = false,
  70.             DSeqPrintPrefs::gShowNoncutters = false;
  71. short    
  72.             DSeqPrintPrefs::gBasesPerLine = 60,
  73. #ifdef WIN_MAC
  74.             DSeqPrintPrefs::gOutFormat = cOutPICT,
  75. #else
  76.             DSeqPrintPrefs::gOutFormat = cOutText,
  77. #endif            
  78.             DSeqPrintPrefs::gREMinCuts = 1, 
  79.             DSeqPrintPrefs::gREMaxCuts = 999;
  80.  
  81.  
  82. char DDrawMapRow::fLinebuf[DDrawMapRow::kMaxLinebuf+1];
  83.  
  84.  
  85.  
  86. // add this to ?? dgg.c
  87. inline void RectRgn(Nlm_RegioN rgn, Nlm_RectPtr r)
  88. {
  89.     Nlm_LoadRectRgn( rgn, r->left, r->top, r->right, r->bottom);
  90. }
  91.  
  92.  
  93. static short gBaseCharWidth = 12;
  94. static short gLineHeight = 12;
  95.  
  96.  
  97. //inline 
  98. static short BaseCharWidth()
  99. {
  100. #ifdef TESTZOOM
  101. #if 1
  102.      gBaseCharWidth= 1;
  103. #else
  104.         // TESTING...
  105.     if (gKeys->shift()) gBaseCharWidth= 1;    else gBaseCharWidth= 12; 
  106.     if (gBaseCharWidth>1) gBaseCharWidth= Nlm_CharWidth('G');
  107. #endif
  108. #else
  109.     gBaseCharWidth= Nlm_CharWidth('G');
  110. #endif
  111.     return gBaseCharWidth;
  112. }
  113.  
  114. //inline 
  115. static short BaseLineHeight()
  116. {
  117.     gLineHeight = Nlm_LineHeight();
  118.     return gLineHeight;
  119. }
  120.  
  121. //inline 
  122. static void BaseDraw( char b)
  123. {
  124. #ifdef TESTZOOM
  125.     if (gBaseCharWidth < 5) {
  126.         Nlm_PoinT pt;
  127.         Nlm_GetPen (&pt);
  128.     Nlm_MoveTo (pt.x, pt.y);
  129.     pt.y -= gLineHeight; //Nlm_LineHeight();
  130.     Nlm_LineTo (pt.x, pt.y);
  131.         }
  132.     else 
  133. #endif
  134.         Nlm_PaintChar(b);
  135. }
  136.  
  137.  
  138.  
  139.  
  140.  
  141. // class DDrawSpacer
  142.  
  143. void DDrawSpacer::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  144. {
  145.     if (fTitle) {
  146.         if (fFont) Nlm_SelectFont(fFont);
  147.         Nlm_MoveTo( r.left, r.bottom-2);
  148.         Nlm_PaintString(fTitle);
  149.         }
  150. }
  151.  
  152. const char* DDrawSpacer::Write( short row, short col, long startitem, long stopitem)
  153. { 
  154.     long  len= Min( kMaxLinebuf, stopitem-startitem);
  155.     Nlm_MemFill(fLinebuf, ' ', len);
  156.     if (fTitle) MemCpy( fLinebuf, fTitle, Min( len, StrLen(fTitle)) );
  157.     fLinebuf[len]= 0;
  158.     return fLinebuf;
  159. }
  160.  
  161.  
  162.  
  163.  
  164. // class DDrawIndexRow 
  165.  
  166. void DDrawIndexRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  167. {  
  168.     short atx, aty, cleft, rowtop;
  169.     short up1, up2, upFont;
  170.     
  171.     if (col>0) startitem += col;
  172.  
  173.     if (fFont) Nlm_SelectFont(fFont);
  174.     cleft= r.left; // add a bit to move over bases
  175.     if (fIsUp) {
  176.         up1= -1;
  177.         up2= -3;
  178.         upFont= -4;
  179.         rowtop= r.bottom - kIndexRise; 
  180.         }
  181.     else {
  182.         up1= 1;
  183.         up2= 3;
  184.         upFont= Nlm_FontHeight();
  185.         rowtop= r.top + kIndexRise;
  186.         }
  187.     Nlm_MoveTo( cleft, rowtop);
  188.     Nlm_LineTo( r.right, rowtop);
  189.     
  190.     cleft += fItemWidth / 2; // add a bit to put tics over bases
  191.     for (long at= startitem; at <= stopitem; at++, cleft += fItemWidth) {
  192.         atx= cleft;
  193.         aty= rowtop;
  194.         Nlm_MoveTo( atx, aty);
  195.         if (at % 10 == 4) {
  196.             char  nums[128];
  197.             sprintf(nums, "%d", at+1);  
  198.             short ws= Nlm_StringWidth(nums);
  199.             aty += up1;
  200.             Nlm_LineTo(atx, aty);
  201.             aty += upFont;
  202.             atx -= ws/2;
  203.             Nlm_MoveTo( atx, aty);
  204.             Nlm_PaintString(nums);
  205.             }        
  206.         else {
  207.           aty += up2;
  208.             Nlm_LineTo(atx, aty);
  209.             }
  210.         }
  211. }
  212.     
  213. const char*  DDrawIndexRow::Write( short row, short col, long startitem, long stopitem)
  214. { 
  215.     long len, i, at;
  216.     char    * numline, * ticline, *cp;
  217.     
  218.     len= Min( kMaxLinebuf / 2, stopitem-startitem);
  219.     Nlm_MemFill( fLinebuf, ' ', (len + 1)*2);
  220.     if (fIsUp) {
  221.       numline= fLinebuf;
  222.         ticline= fLinebuf + len + 1;
  223.         }
  224.     else {
  225.       ticline= fLinebuf;
  226.         numline= fLinebuf + len + 1;
  227.         }
  228.     
  229.     for (i= 0, at=startitem; i < len; i++, at++) {
  230.         if (at % 10 == 4) {
  231.             char nums[128];
  232.             short  ws;
  233.             ticline[i]= '+';
  234.           sprintf(nums, "%d", at+1);
  235.           ws= StrLen(nums);
  236.           cp= numline + i - ws / 2;
  237.           MemCpy( cp, nums, ws);
  238.             }
  239.         //else if (fIsUp) ticline[i]= '_'; 
  240.         else 
  241.             ticline[i]= '-';
  242.         }
  243.  
  244.         fLinebuf[len]= '\n'; // newline !?
  245.         len= 2*len + 1;
  246.         fLinebuf[len]= 0;
  247.         return fLinebuf;
  248. }
  249.     
  250.     
  251.  
  252. // class DDrawSeqRow
  253.  
  254. DDrawSeqRow::DDrawSeqRow(Nlm_FonT itsFont, DSeqPrintView* itsView, DSequence* itsSeq,
  255.                                                      DList* itsStyles, char* name, ulong* colors) : 
  256.         fView(itsView), fColors(colors), 
  257.         fSeq(itsSeq), fTopSeq(NULL), fBotSeq(NULL),
  258.         fStyles( itsStyles), 
  259.         fFirstcommon(NULL), fCommonbase(NULL),
  260.         fBases(NULL), fLength(0)
  261. {  
  262.     if (fSeq) {
  263.         fBases= fSeq->Bases();
  264.         fLength= fSeq->LengthF();
  265.         }
  266.     fFont= itsFont; 
  267.     if (name) StrNCpy( fNameStore, name, sizeof(fNameStore)); 
  268.     else *fNameStore= 0;
  269.     fName= fNameStore; 
  270.     if (fFont) Nlm_SelectFont(fFont);
  271.     fHeight= BaseLineHeight();
  272.     fItemWidth= BaseCharWidth();
  273. }
  274.  
  275.  
  276. DSeqStyle* DDrawSeqRow::GetStyle(long ibase, short masklevel, DSequence* aSeq)
  277. {
  278.     short maskval= 0;
  279.     if (aSeq) maskval= aSeq->MaskAt(ibase, masklevel);
  280.     if (maskval>0)  
  281.         return (DSeqStyle*) fStyles->At(masklevel-1);
  282.     else
  283.         return NULL;
  284. }
  285.  
  286.  
  287. void DDrawSeqRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  288. {
  289.     enum patvals { kNoPat, kHasFillPat, kHasFramePat };
  290.     char* bases= fBases;
  291.     if (bases && startitem < fLength) {
  292.     char    ch, lastch, *b;
  293.     short    atx, aty, masklevel, maskval;
  294.     long    ibase;
  295.     ulong    newcolor, curcolor, blackcolor;
  296.     patvals  haspat= kNoPat;
  297.          DSeqStyle * style, * laststyle, * nextstyle, * topstyle, * botstyle;
  298.    
  299.         if (col>0) {
  300.             bases += col; 
  301.             startitem += col;
  302.             }
  303.         if (stopitem > fLength) stopitem= fLength;
  304.         long len= stopitem - startitem;
  305.         atx= r.left;
  306.         aty= r.bottom - 2;
  307.         
  308.         if (fFont) Nlm_SelectFont(fFont);
  309.         Nlm_Black();
  310.         Nlm_TextTransparent();
  311.         curcolor= blackcolor= Nlm_GetColor();
  312.         
  313. #if MASKS
  314.         topstyle= botstyle= NULL;
  315.         laststyle= nextstyle= NULL;
  316.         if (startitem>0) 
  317.          for (masklevel=1; masklevel<5; masklevel++) {
  318.             laststyle= GetStyle( startitem-1, masklevel, fSeq);
  319.             if (laststyle) break;
  320.             }
  321. #endif
  322.             
  323.         lastch= 0;
  324.         for (b= bases + startitem, ibase=startitem; *b && ibase<stopitem; b++, ibase++) {
  325.             Nlm_MoveTo( atx, aty);
  326.             ch= *b;
  327.             if (ch == DSequence::indelSoft) ch= DSequence::indelHard; //looks better for output...
  328.     
  329. #if MASKS
  330.             Boolean needdraw= true;
  331.             Nlm_RecT crec;
  332.             maskval= fSeq->MaskAt(ibase,0); // val for all masks
  333.             if (maskval>0) 
  334.              for (masklevel=1; needdraw && masklevel<5; masklevel++) {
  335.                     // LATER: want to allow drawing of all mask forms for each base !?
  336.                 style= GetStyle( ibase, masklevel, fSeq);
  337.                 if (style) {
  338.                     Nlm_LoadRect( &crec, atx, r.top, atx+fItemWidth, r.bottom);
  339.                     nextstyle= GetStyle( ibase+1, masklevel, fSeq);
  340.                     topstyle= GetStyle( ibase, masklevel, fTopSeq);
  341.                     botstyle= GetStyle( ibase, masklevel, fBotSeq);
  342.  
  343. #if 1
  344.                     if (style->repeatchar && fItemrow > 0 
  345.                         && fCommonbase && fFirstcommon
  346.                         && fCommonbase[ibase] != '!'
  347.                         && fItemrow > (unsigned char)fFirstcommon[ibase]
  348.                         && toupper(ch) == fCommonbase[ibase]) 
  349.                           ch= style->repeatchar;
  350. #else                    
  351.                     if (style->repeatchar && fItemrow > 0 
  352.                         && DStyleTable::fToprow 
  353.                         && ibase < DStyleTable::fToprowlen 
  354.                         && ch == DStyleTable::fToprow[ibase]) 
  355.                           ch= style->repeatchar;
  356. #endif
  357.                           
  358.                     if (style->uppercase) ch= toupper(ch);
  359.                     else if (style->lowercase) ch= tolower(ch);
  360.                     
  361.                     if (style->font && 
  362.                     (style->font != Nlm_fontInUse || style->font != DStyleTable::fLaststyle.font)) 
  363.                           Nlm_SelectFont(style->font);
  364.                          
  365.                         // this is good only w/ backcolor !?
  366.                      if (style->dofontpat) { 
  367.                         if ( haspat == kHasFillPat || 
  368.                          (Nlm_MemCmp(style->fontpattern, DStyleTable::fLaststyle.fontpattern, 8) != 0)
  369.                          ) {
  370.                              Nlm_PenPattern(style->fontpattern);  
  371.                              haspat= kHasFillPat;
  372.                              }
  373.                          }
  374.                      else if (haspat) { Nlm_Solid(); haspat= kNoPat; }
  375.                              
  376.                     if (style->dobackcolor) { 
  377.                         newcolor= style->backcolor;
  378.                         if (curcolor != newcolor) {
  379.                             curcolor= newcolor;
  380.                             Nlm_SetColor( curcolor);  
  381.                             }
  382.                         Nlm_PaintRect(&crec);
  383.                         }  
  384.  
  385.                     if (style->dofontcolor) newcolor= style->fontcolor;
  386.                     else if (fColors) newcolor= fColors[ch-' '];
  387.                     else newcolor= blackcolor;  
  388.                     if (curcolor != newcolor) {
  389.                         curcolor= newcolor;
  390.                         Nlm_SetColor( curcolor);  
  391.                         }
  392.  
  393.                     //if (style->invertcolor) Nlm_InvertColors();
  394.                     //if (style->invertcolor) Nlm_EraseMode();//TextMode(srcBIC);
  395.                     
  396.                     BaseDraw(ch);
  397.                     needdraw= false;
  398.  
  399.                     //if (style->invertcolor) Nlm_CopyMode();
  400.                     if (style->invertcolor) Nlm_InvertRect( &crec);
  401.                     
  402.                     if (style->frame) { 
  403.                         Boolean anyframe, leftframe, rightframe, topframe, botframe;
  404.                         leftframe = (!(laststyle && laststyle->frame));
  405.                         rightframe= (!(nextstyle && nextstyle->frame));
  406.                         topframe  = (!(topstyle && topstyle->frame));
  407.                         botframe  = (!(botstyle && botstyle->frame));
  408.                         anyframe  = leftframe||rightframe||topframe||botframe;
  409.                         
  410.                         if (anyframe) { 
  411.                           if (style->doframecolor) newcolor= style->framecolor;
  412.                             else newcolor= blackcolor; 
  413.                             if (curcolor != newcolor) {
  414.                                 curcolor= newcolor;
  415.                                 Nlm_SetColor( curcolor);  
  416.                                 }
  417.                              if (style->framestyle) { 
  418.                                  switch (style->framestyle) {
  419.                                      case DSeqStyle::kFrameSolid : Nlm_Solid(); break;
  420.                                      case DSeqStyle::kFrameDark  : Nlm_Dark(); break;
  421.                                      case DSeqStyle::kFrameMedium: Nlm_Medium(); break;
  422.                                      case DSeqStyle::kFrameLight : Nlm_Light(); break;
  423.                                      case DSeqStyle::kFrameDotted: Nlm_Dotted(); break;
  424.                                      case DSeqStyle::kFrameDashed: Nlm_Dashed(); break;
  425.                                      }
  426.                                  }
  427.                              haspat= kHasFramePat;
  428.                             }
  429.  
  430.                         if (leftframe) { 
  431.                             Nlm_MoveTo(crec.left,crec.top); 
  432.                             Nlm_LineTo(crec.left,crec.bottom); 
  433.                             } 
  434.                         if (rightframe) { 
  435.                             Nlm_MoveTo(crec.right-1,crec.top); 
  436.                             Nlm_LineTo(crec.right-1,crec.bottom); 
  437.                             } 
  438.                         if (topframe) { 
  439.                             Nlm_MoveTo(crec.left,crec.top); 
  440.                             Nlm_LineTo(crec.right,crec.top); 
  441.                             } 
  442.                         if (botframe) { 
  443.                             Nlm_MoveTo(crec.left,crec.bottom-1); 
  444.                             Nlm_LineTo(crec.right,crec.bottom-1); 
  445.                             } 
  446.                         if (anyframe) Nlm_TextTransparent(); // MSWin LineTo/DrawLine resets Opaque!
  447.                         }
  448.  
  449.                     DStyleTable::fLaststyle= *style;
  450.                     laststyle= style;
  451.                     }
  452.                 }
  453.             
  454.             if (needdraw) {
  455.                 if (haspat) { Nlm_Solid(); haspat= kNoPat; }
  456.                  if (Nlm_fontInUse != fFont) Nlm_SelectFont(fFont); 
  457.                 if (fColors) {
  458.                     newcolor= fColors[ch-' '];
  459.                     if (curcolor != newcolor) {
  460.                         curcolor= newcolor;
  461.                         Nlm_SetColor( curcolor);  
  462.                         }
  463.                     }
  464.                 else if (curcolor != blackcolor) {
  465.                     Nlm_Black(); // if WithStyle left a color set.... !!
  466.                     curcolor= blackcolor;
  467.                     }
  468.                 BaseDraw(ch);
  469.                 laststyle= NULL;
  470.                 }
  471.  
  472. #else
  473.              if (fColors) {
  474.                  // if (swapBackcolor) Nlm_SetBackColor( fColors[ch-' ']); else 
  475.                 if (ch!=lastch) Nlm_SetColor( fColors[ch-' ']);
  476.                 }
  477.             BaseDraw(ch);
  478. #endif
  479.             lastch= ch;
  480.             atx += fItemWidth;   
  481.             }    
  482.         Nlm_TextOpaque();
  483.         Nlm_Black();
  484.         if (haspat) { Nlm_Solid(); haspat= kNoPat; }
  485.         curcolor= blackcolor;
  486.         }
  487. }
  488.  
  489. const char* DDrawSeqRow::Write( short row, short col, long startitem, long stopitem)
  490. { 
  491.     long  len, i;
  492.     char* bases= fBases;
  493.     len= Min( kMaxLinebuf, stopitem-startitem);
  494.     if (bases && startitem < fLength) {
  495.     char    ch, *b;
  496.         if (stopitem > fLength) stopitem= fLength;        
  497.         for (b= bases + startitem, i=0; *b && i<len; b++, i++) {
  498.             ch= *b;
  499.             if (ch == DSequence::indelSoft) ch= DSequence::indelHard; //looks better
  500.             fLinebuf[i]= ch;
  501.             }    
  502.         for ( ; i<len; i++) fLinebuf[i]= ' ';
  503.         }
  504.     fLinebuf[len]= 0;
  505.     return fLinebuf;
  506. }
  507.     
  508.     
  509.  
  510. // class DDrawManySeqRow
  511.  
  512.  
  513.  
  514. DDrawManySeqRow::DDrawManySeqRow(Nlm_FonT itsFont, DSeqPrintView* itsView, 
  515.                                             DSeqList* seqlist, long seqIndex, DList* itsStyles, ulong* colors,
  516.                                             char* commonbases, char* firstcommon) : 
  517.       DDrawSeqRow( itsFont, itsView, NULL, itsStyles, NULL, colors),
  518.         fSeqList(seqlist)
  519. {
  520.     fItemrow= seqIndex;
  521.     fSeq= seqlist->SeqAt( fItemrow);
  522.     if (fSeq) {
  523.         StrNCpy( fNameStore, fSeq->Name(), sizeof(fNameStore));
  524.         fName= fNameStore;
  525.         fBases= fSeq->Bases();
  526.         fLength= fSeq->LengthF();
  527.         }
  528.     fTopSeq= seqlist->SeqAt(fItemrow-1);
  529.     fBotSeq= seqlist->SeqAt(fItemrow+1);
  530.     fCommonbase= commonbases;
  531.     fFirstcommon= firstcommon;
  532.     //fCommonbase= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, fFirstcommon);
  533. }
  534.  
  535. #if 0
  536. DDrawManySeqRow::~DDrawManySeqRow()
  537. {
  538. }
  539.  
  540. char* DDrawManySeqRow::GetName(short row)
  541. {
  542.     //DSequence* aSeq= NULL;
  543.     //short atseq= (row % fLinesPerparag) - fTopPerparag;
  544.     //if (fItemrow>=0) aSeq= (DSequence*) fSeqList->At( fItemrow);
  545.     //if (fSeq) return fSeq->Name(); else 
  546.     return fName;
  547. }
  548.  
  549. void DDrawManySeqRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  550. {
  551.     //DSequence* aSeq= NULL;
  552. //    short atseq= (row % fLinesPerparag) - fTopPerparag; // == fItemrow
  553.     //if (fItemrow>=0) aSeq= (DSequence*) fSeqList->At(fItemrow);
  554.     if (fSeq) {
  555.         //fSeq= aSeq;
  556.         //fTopSeq= (DSequence*) fSeqList->At(fItemrow-1);
  557.         //fBotSeq= (DSequence*) fSeqList->At(fItemrow+1);
  558.         //fBases= aSeq->Bases();
  559.         //fLength= aSeq->LengthF();
  560.       DDrawSeqRow::Draw( r, row, col, startitem, stopitem);
  561.         }
  562. }
  563.  
  564. const char* DDrawManySeqRow::Write( short row, short col, long startitem, long stopitem)
  565. { 
  566.     //DSequence* aSeq= NULL;
  567. //    short atseq= (row % fLinesPerparag) - fTopPerparag;
  568.     //if (fItemrow>=0) aSeq= (DSequence*) fSeqList->At(fItemrow);
  569.     if (fSeq) {
  570.         //fSeq= aSeq;
  571.         //fBases= aSeq->Bases();
  572.         //fLength= aSeq->LengthF();
  573.       return DDrawSeqRow::Write( row, col, startitem, stopitem);
  574.         }
  575.     else
  576.         return "";
  577. }
  578.  
  579. #endif
  580.  
  581.  
  582.  
  583. // class DDrawAminoRow
  584.  
  585.  
  586. DDrawAminoRow::DDrawAminoRow(Nlm_FonT itsFont, DSequence* itsSeq, short frame) : 
  587.         fAAseq(NULL), fFrame( frame), fLength(0), 
  588.         fOnlyORF(DSeqPrintPrefs::gOnlyORF),
  589.         fThreeLet(DSeqPrintPrefs::gThreeLetAA) 
  590. {
  591.     Boolean iscomp = frame > 2;
  592.     short   offset = frame % 3;
  593.     fFont= itsFont;
  594.     if (fFont) Nlm_SelectFont(fFont);
  595.     fHeight= BaseLineHeight();
  596.     fItemWidth= BaseCharWidth();
  597.     sprintf( fNameStore, "aa%d", frame);
  598.     fName= fNameStore;
  599.     if (iscomp) {
  600.         itsSeq->SetSelection( -1,-1);
  601.         itsSeq= itsSeq->Reverse();
  602.             // strange patches...
  603.         if (offset==1) offset= 2;     
  604.         else if (offset==2) offset= 1; 
  605.         if (offset==2) itsSeq->InsertSpacers(itsSeq->LengthF(),offset,'?');   
  606.         }
  607.     itsSeq->SetSelection( offset, itsSeq->LengthF() - offset);
  608.     fAAseq= itsSeq->Translate(false);
  609.     if (iscomp) { delete itsSeq; itsSeq= NULL; }
  610.     if (fAAseq) {
  611.         fBases= fAAseq->Bases();
  612.         fLength= fAAseq->LengthF();
  613.         if (fOnlyORF) {
  614.             long    i;
  615.             Boolean isorf;
  616.             char startamino= DCodons::startamino();
  617.             for (isorf= true, i= 0; i<fLength; i++) {
  618.                 if (isorf) {
  619.                   if (fBases[i] == '*') isorf= false;
  620.                   }
  621.                 else {
  622.                      if (fBases[i] == startamino) isorf= true;
  623.                      if (!isorf) fBases[i]= ' ';
  624.                     }
  625.                 }
  626.             }
  627.         if (iscomp) { 
  628.             fAAseq->SetSelection( -1,-1);
  629.             DSequence* unrevAA= fAAseq->Reverse(); 
  630.             delete fAAseq; 
  631.             fAAseq= unrevAA; 
  632.             fBases= fAAseq->Bases();
  633.             fLength= fAAseq->LengthF();
  634.             }
  635.         }
  636. }
  637.  
  638. void DDrawAminoRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  639. {
  640.     long   len;
  641.     short  leftindent;
  642.     char*  bases= fBases;
  643.     if (bases) {
  644.         if (col) {
  645.             bases += col; 
  646.             startitem += col;
  647.             }
  648. #if 0
  649.       short indents[3,3] = {
  650.                           {0,1,2},
  651.                                                 {2,0,1},
  652.                                               {1,2,0}
  653.                                                 };
  654.         // at   0 -> 0,1,2 now & want          0%3=0
  655.         // at  50 -> 2,0,1 now -> 1,2,0 want  50%3=2
  656.         // at 100 -> 1,2,0 now -> 2,0,1 want 100%3=1
  657.         // at 150 -> 0,1,2 now & want        150%3=0
  658. #endif
  659.         leftindent=  (fFrame + (3 - (startitem % 3)) % 3) % 3; 
  660.         
  661.         len= (stopitem - startitem + 2) / 3;
  662.         startitem = (startitem + 2) / 3;  // adjust for 3-to-1 NA-to-AA translate
  663.         if (startitem + len > fLength) len= fLength - startitem;
  664.         if (startitem < fLength) {
  665.         char     *b;
  666.         short  chleft, chvert, chwidth;
  667.             
  668.             chvert= r.bottom-2;
  669.             chwidth = fItemWidth; 
  670.             chleft = r.left + chwidth * leftindent;    
  671.             chwidth *= 3;    
  672.             if (fFont) Nlm_SelectFont(fFont);
  673.             if (fThreeLet) for (b= bases+startitem; *b && len; b++, len--) {
  674.                 Nlm_MoveTo( chleft, chvert);
  675.                 Nlm_PaintString( (char*) DSequence::Amino123(*b));
  676.                 chleft += chwidth;
  677.                 }
  678.             else for (b= bases+startitem; *b && len; b++, len--) {
  679.                 Nlm_MoveTo( chleft, chvert);
  680.                 BaseDraw(*b);
  681.                 chleft += chwidth;
  682.                 }        
  683.             }
  684.         }
  685. }
  686.  
  687. const char* DDrawAminoRow::Write( short row, short col, long startitem, long stopitem)
  688. { 
  689.     long   len, alen;
  690.     short  leftindent;
  691.     char*  bases= fBases;
  692.     if (bases) {
  693.         len= Min( kMaxLinebuf, 1+stopitem-startitem);
  694.         Nlm_MemFill( fLinebuf, ' ', len);
  695.         
  696.         leftindent=  (fFrame + (3 - (startitem % 3)) % 3) % 3; 
  697.         
  698.         alen= (stopitem - startitem + 2) / 3;
  699.         startitem = (startitem + 2) / 3;  // adjust for 3-to-1 NA-to-AA translate
  700.         if (startitem + alen > fLength) alen= fLength - startitem;
  701.         if (startitem < fLength) {
  702.         char    *b, *cp;
  703.         long    i;
  704.             i= leftindent;    
  705.             if (fThreeLet) 
  706.              for (b= bases+startitem; *b && alen && i<len; b++, alen--, i += 3) {
  707.                 char * amino3= (char*) DSequence::Amino123(*b);
  708.                 cp= fLinebuf + i;
  709.                 MemCpy( cp, amino3, 3);
  710.                 }
  711.             else 
  712.              for (b= bases+startitem; *b && alen && i<len; b++, alen--, i += 3) {
  713.                 fLinebuf[i]= *b;
  714.                 }        
  715.             }
  716.         }
  717.     fLinebuf[len]= 0;
  718.     return fLinebuf;
  719. }
  720.     
  721.  
  722.  
  723.  
  724.  
  725.  
  726. /******** 
  727. methods & fields for various draw objects:
  728.   single-seq
  729.   multi-seq  
  730.     single-seq [+rezymes] [+complement] [+amino-trans] [+... others]
  731.   multi-seq  [+?consensus] [+?? annotations of various kinds for mseq ] 
  732.   
  733.   fSeqsPerParag
  734.   fSeqLinesPerParag
  735.   fSpacersPerParag
  736.   
  737.   DRowDrawer* GetRowDrawer( atseq):
  738.         Spacer, TopIndex, 
  739.         SeqLine(s), ComplSeqLine,
  740.          AA[1-3], CompAA[1-3], RestEnzyme
  741.   
  742.   make fRowsList [1..fLinesPerParag] of DRowDrawer objects...
  743.   
  744.   calcs:
  745.     //linesPerParag = fSeqLinesPerParag + fSpacersPerParag
  746.     atseq  = (row % fLinesPerParag)
  747.         seqline= (row / fLinesPerParag) * seqsperparag;  
  748.         startcol= seqline * fBasesPerLine;
  749.         stopcol = startcol + fBasesPerLine;
  750. *****/
  751.  
  752.  
  753.  
  754.  
  755.  
  756. // class DSeqPrintView
  757.  
  758.  
  759.  
  760. DSeqPrintView::DSeqPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  761.                                  DSeqList* itsSeqList, long firstbase, long nbases,
  762.                                  long pixwidth, long pixheight):
  763.     DTableView( id, itsSuper, pixwidth, pixheight, 0, 0,  
  764.                             Nlm_stdCharWidth, Nlm_stdLineHeight, true, true),
  765.     fDoc(itsDocument), fSeqList(itsSeqList), fSeq(NULL), 
  766.     fDrawRowList(NULL), fStyles(NULL),
  767.     fCommonbase(NULL), fFirstcommon(NULL),
  768.     fFirstBase(firstbase), fNbases(nbases), fMaxbases(nbases),
  769.     fSeqLinesPerParag(kSeqLinesPerParag), fTopPerparag(2),
  770.     fLinesPerParag(kSeqLinesPerParag+2), fSeqWidth(0),
  771.     fBasesPerLine(DSeqPrintPrefs::gBasesPerLine), fExtrarows(0),
  772.     fIndexWidth(kIndexWidth), fIndexWidthCnt(5),
  773.     fNameWidth(kNameWidth), fNameWidthCnt(8)
  774.  
  775. { 
  776.         // testing reduced view
  777.     if (gKeys->shift()) gBaseCharWidth= 1;    else gBaseCharWidth= 12; 
  778.  
  779.     this->SetSlateBorder( false);
  780.     this->SetResize( DView::relsuper, DView::relsuper);
  781.     this->SetTableFont(gTextFont);
  782.     fBaseWidth= BaseCharWidth();
  783.     fOneseq= fSeqList->GetSize()<2; 
  784.     
  785.   fSeq= (DSequence*) fSeqList->At(0);
  786.  
  787.     Initialize();  
  788. }
  789.  
  790.  
  791. void DSeqPrintView::FreeLists()
  792. {
  793.     short i, n;
  794.     if (fDrawRowList) {
  795.         n= fDrawRowList->GetSize();
  796.         for (i=0; i<n; i++) {
  797.             DDrawMapRow    *    arow= (DDrawMapRow*) fDrawRowList->At(i);
  798.             delete arow;
  799.             }
  800.         delete fDrawRowList;
  801.         }
  802.     if (fStyles) {
  803.         n= DStyleTable::fStyles->GetSize();
  804.         for (i=0; i<n; i++) {
  805.             DSeqStyle    *    astyle= (DSeqStyle*) DStyleTable::fStyles->At(i);
  806.             delete astyle;
  807.             }
  808.         delete fStyles;
  809.         }
  810. }
  811.  
  812. DSeqPrintView::~DSeqPrintView()
  813. {    
  814.     //fDrawRowList= FreeListIfObject(fDrawRowList);
  815.     //fStyles= FreeListIfObject(fStyles);
  816.     FreeLists();
  817.     MemFree( fCommonbase);
  818.     MemFree( fFirstcommon);
  819. }
  820.  
  821. void DSeqPrintView::Initialize()
  822. { 
  823.     fDoTopIndex= DSeqPrintPrefs::gIndexTop;
  824.     fDoLeftIndex= DSeqPrintPrefs::gIndexLeft; 
  825.     fDoRightIndex= DSeqPrintPrefs::gIndexRight;  
  826.     fDoLeftName= DSeqPrintPrefs::gNameLeft; 
  827.     fDoRightName= DSeqPrintPrefs::gNameRight;
  828.     
  829.     fNameFont = DSeqPrintPrefs::gNameFont;
  830.     fNumFont  = DSeqPrintPrefs::gIndexFont;
  831.     fBaseFont = DSeqPrintPrefs::gBaseFont;
  832. }
  833.  
  834.  
  835. void DSeqPrintView::MakeDrawList()
  836. {
  837.     short i, n;
  838.  
  839.     FreeLists();
  840.     //fDrawRowList= FreeListIfObject(fDrawRowList);
  841.     fDrawRowList= new DList(); // NULL, DList::kDeleteObjects << bad, doesn't call destruct
  842.     fDrawRowList->InsertLast( new DDrawSpacer());
  843.     if (fDoTopIndex) 
  844.         fDrawRowList->InsertLast( new DDrawIndexRow(fNumFont,fBaseWidth));
  845.  
  846.     ulong * colors;
  847.     //if (!fDoc->fUseColor) colors= NULL;
  848.     if (!DSeqPrintPrefs::gColored) colors= NULL;
  849.     else if (fSeq->Kind() == DSequence::kAmino) colors= DBaseColors::gAAcolors;
  850.     else colors= DBaseColors::gNAcolors;
  851.  
  852.     //fStyles= FreeListIfObject(fStyles);
  853.     fStyles= new DList(); // NULL,DList::kDeleteObjects << bad
  854.     n= DStyleTable::fStyles->GetSize();
  855.     for (i=0; i<n; i++) {
  856.         DSeqStyle    *    astyle= (DSeqStyle*) DStyleTable::fStyles->At(i);
  857.         astyle= (DSeqStyle*) astyle->Clone();
  858.         fStyles->InsertLast( astyle);
  859.         }
  860.         
  861.     if (!fOneseq) {
  862.         fCommonbase= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, fFirstcommon);
  863.         for (i= 0; i < fSeqLinesPerParag; i++) {
  864.           DDrawManySeqRow* dd= new DDrawManySeqRow( fBaseFont, this, fSeqList, i, 
  865.                   fStyles, colors, fCommonbase, fFirstcommon);
  866.           fDrawRowList->InsertLast(dd);
  867.             }
  868.         }
  869.     else {
  870.       for (i= 0; i < fSeqLinesPerParag; i++) { 
  871.             DDrawSeqRow* dd= new DDrawSeqRow( fBaseFont, this, fSeq, fStyles, fSeq->Name(), colors);
  872.           fDrawRowList->InsertLast( dd);
  873.            }    
  874.     }
  875. }
  876.  
  877.  
  878. void DSeqPrintView::GetReadyToShow()
  879. {
  880.     char nums[50];
  881.     long diff, nrows, nbases= 0;
  882.  
  883.     if (fOneseq)    {
  884.         fSeqsperparag = fSeqLinesPerParag;
  885.         }
  886.   else {
  887.         fSeqLinesPerParag= fSeqList->GetSize(); //?? or leave to subclasses?
  888.         fSeqsperparag = 1;
  889.         }
  890.     /* if (dospacer) */ fLinesPerParag = 1; fTopPerparag= 1;
  891.     if (fDoTopIndex) { fLinesPerParag++; fTopPerparag++; }
  892.     fLinesPerParag += fSeqLinesPerParag;
  893.  
  894. #if 1
  895.     if (fNbases) nbases= fNbases;
  896.     else
  897. #endif
  898.     if (fSeqList) {
  899.         short i, nseq= fSeqList->GetSize();
  900.         for (i=0; i<nseq; i++) {
  901.             DSequence* aseq= fSeqList->SeqAt(i);
  902.             nbases= Max(nbases, aseq->LengthF());
  903.             }
  904.         fNbases= nbases; 
  905.         }
  906.     else if (fSeq) { nbases= fSeq->LengthF(); fNbases= nbases; }
  907.     fMaxbases= nbases;
  908.     
  909.     // assume port is set??
  910.     SelectFont();
  911.     if (fNameFont) Nlm_SelectFont(fNameFont);  
  912.     fNameWidth= 5 + Nlm_StringWidth("Sequence");
  913.     fNameWidthCnt= 8;
  914.     
  915.     if (fNumFont) Nlm_SelectFont(fNumFont);  
  916.     sprintf( nums, "%d", fMaxbases);
  917.     fIndexWidthCnt= StrLen(nums);
  918.     fIndexWidth= 5 + fIndexWidthCnt * Nlm_CharWidth('0');
  919.  
  920.     if (fBaseFont) Nlm_SelectFont(fBaseFont);  
  921.     fBaseWidth= BaseCharWidth();  
  922.     
  923.     short ncols= fBasesPerLine + 4;
  924.     if (ncols > GetMaxCols()) ChangeColSize( -1, ncols-GetMaxCols());
  925.  
  926.   MakeDrawList();
  927.  
  928.     SetItemWidth( 0, 1, (fDoLeftName)?fNameWidth:1);
  929.     SetItemWidth( 1, 1, (fDoLeftIndex)?fIndexWidth:1);
  930.     SetItemWidth( 2, fBasesPerLine, fBaseWidth);  
  931.   fSeqWidth= fBasesPerLine * fBaseWidth; //!?!?
  932.     SetItemWidth( fBasesPerLine+2, 1, (fDoRightIndex)?fIndexWidth:1);
  933.     SetItemWidth( fBasesPerLine+3, 1, (fDoRightName)?fNameWidth:1);
  934.  
  935.     nrows= 1 + (nbases / fBasesPerLine) / fSeqsperparag;
  936.     nrows *= fLinesPerParag;
  937.     nrows += GetExtraRows();
  938.     diff  = Max( 3, nrows) - GetMaxRows();
  939.     ChangeRowSize( -1, diff);  // -1 prevents redraw..else use fMaxRows    
  940.  
  941.     Nlm_RecT  r;
  942.     ViewRect(r);
  943.     nrows= GetMaxRows();  
  944.     for (long irow=0; irow<nrows; irow++) {
  945.         long itemrow, seqline, startitem, stopitem;
  946.         IndexFromRow( irow, itemrow, seqline, startitem, stopitem);
  947.         DDrawMapRow* drawer= (DDrawMapRow*) fDrawRowList->At(itemrow);
  948.         SetItemHeight( irow, 1, 
  949.             (drawer) ? drawer->GetHeight(r, irow, startitem, stopitem) : Nlm_stdLineHeight);
  950.         }
  951.         
  952. }
  953.  
  954.  
  955. void DSeqPrintView::DrawSideIndex( Nlm_RecT& aRect, long index, long leftBorder)
  956. {
  957.     if (index != DDrawMapRow::kNoIndex) {
  958.         char nums[128];
  959.         Nlm_SelectFont(fNumFont); 
  960.         sprintf(nums, "%d", index); // or char* nump= ltoa(index);
  961.         short atx= aRect.right - leftBorder - Nlm_StringWidth(nums);
  962.         Nlm_MoveTo( atx, aRect.bottom - kFontDescent);
  963.         Nlm_PaintString(nums);
  964.         }
  965. }
  966.  
  967. void DSeqPrintView::WriteSideIndex( long index, long leftBorder)
  968. {
  969.     char fmt[30];
  970.     if (index != DDrawMapRow::kNoIndex) {
  971.         if (leftBorder > 0) sprintf( fmt, " %%%dd",fIndexWidthCnt);
  972.         else sprintf( fmt, " %%-%dd",fIndexWidthCnt);
  973.         fprintf( fFile->fFile, fmt, index);
  974.         }
  975.     else {
  976.         sprintf( fmt, " %%%ds",fIndexWidthCnt);
  977.         fprintf( fFile->fFile, fmt, "");
  978.         }
  979. }
  980.  
  981. void DSeqPrintView::DrawName( Nlm_RecT& aRect, short rightBorder, char* name)
  982. {
  983.     if (name) {
  984.         Nlm_SelectFont(fNameFont); 
  985.         short ht= 2 * Nlm_stdLineHeight;
  986.         if (aRect.bottom - aRect.top > ht)
  987.             Nlm_MoveTo( aRect.left + rightBorder, aRect.top + ht);
  988.         else     
  989.             Nlm_MoveTo( aRect.left + rightBorder, aRect.bottom - kFontDescent);
  990.         Nlm_PaintString( name);
  991.         } 
  992. }
  993.  
  994. void DSeqPrintView::WriteName( short rightBorder, char* name)
  995. {
  996.     char fmt[30];
  997.     if (rightBorder > 0) sprintf( fmt, "  %%-%ds",fNameWidthCnt);
  998.     else sprintf( fmt, "%%%ds ",fNameWidthCnt);
  999.     if (!name) name= "";
  1000.     fprintf( fFile->fFile, fmt, name);
  1001. }
  1002.  
  1003.  
  1004. void DSeqPrintView::IndexFromRow( long row, long& itemrow, long& seqline, long& startitem, long& stopitem)
  1005. {
  1006.     itemrow    = (row % fLinesPerParag);  
  1007.     seqline = (row / fLinesPerParag) * fSeqsperparag;   
  1008.     if (fOneseq) seqline += Max( 0, itemrow - fTopPerparag);
  1009. #if 1
  1010.     startitem = fFirstBase + seqline * fBasesPerLine;
  1011.     stopitem  = Min(startitem + fBasesPerLine, fFirstBase+fNbases);
  1012.     if (startitem>stopitem) { startitem= stopitem; }
  1013. #else
  1014.     startitem = seqline * fBasesPerLine;
  1015.     stopitem  = startitem + fBasesPerLine;
  1016. #endif
  1017. }
  1018.  
  1019.  
  1020. void DSeqPrintView::Draw()
  1021. {
  1022. #if MASKS
  1023.             // !! toprowbases should be just CONSENSUS/Common bases, not rare ones
  1024. #if 0
  1025.     short minCommonPerCent= 70;
  1026.     char * commons= FindCommonBases( minCommonPerCent); 
  1027.      // ^^ OOPs, this is made new for each draw .. bad news
  1028.     DStyleTable::StartDraw( commons, StrLen(commons));
  1029. #else
  1030.     //DSequence* aSeq= fSeqList->SeqAt(0);
  1031.     DStyleTable::StartDraw( fSeq->Bases(), fSeq->LengthF());
  1032. #endif
  1033. #endif
  1034.  
  1035.     DTableView::Draw();
  1036.     
  1037. #if MASKS
  1038.     DStyleTable::EndDraw();
  1039. #endif
  1040. }
  1041.  
  1042. void DSeqPrintView::DrawRow(Nlm_RecT r, long row)
  1043. {
  1044.     long             itemrow, seqline, startitem, stopitem;
  1045.     long         col, ncols;
  1046.     Nlm_RecT    r1, viewr;
  1047.     Nlm_RegioN     cliprgn;
  1048.     DDrawMapRow * drawer;
  1049.     
  1050.     col = GetLeft(); 
  1051.     if (fWidths && col <= fMaxCols) r.right= r.left + fWidths[col];
  1052.     else r.right= r.left + fItemWidth;
  1053.     ViewRect( viewr);
  1054.  
  1055.     IndexFromRow( row, itemrow, seqline, startitem, stopitem);
  1056.   cliprgn= Nlm_CreateRgn();
  1057.     drawer= (DDrawMapRow*) fDrawRowList->At(itemrow);
  1058.   
  1059.     if (drawer) {
  1060.         drawer->fItemrow= itemrow - fTopPerparag;// so we know which seq line in array
  1061.         while (r.left < fRect.right && col < fMaxCols) {
  1062.             if (col < 2 || col > fBasesPerLine+1) {
  1063.                         // do name & index borders
  1064.                 ncols= 1;
  1065.                 if (col == 0 && !fDoLeftName && drawer->DoLeftName()) // special case, fiddle w/ clip rgn...
  1066.                     { r.right += fItemWidth; }
  1067.                 (void) Nlm_SectRect( &r, &viewr, &r1);
  1068.                 RectRgn( cliprgn, &r1);  
  1069.                 Nlm_SectRgn( cliprgn, Nlm_updateRgn, cliprgn);
  1070.                 if ( !Nlm_EmptyRgn( cliprgn)) {
  1071.                     Nlm_ClipRgn(cliprgn);
  1072.                     r1= r;
  1073.                     if (col == 0) {
  1074.                         if (fDoLeftName || drawer->DoLeftName()) DrawName( r1, 0, drawer->GetName(row));
  1075.                         }
  1076.                     else if (col == 1) {
  1077.                         if (fDoLeftIndex) DrawSideIndex( r1, drawer->GetIndex(startitem), kNucBorder);
  1078.                         }
  1079.                     else if (col == fBasesPerLine+2) {
  1080.                         if (fDoRightIndex) DrawSideIndex( r1,  drawer->GetIndex(stopitem), 0);
  1081.                         }
  1082.                     else if (col == fBasesPerLine+3) {
  1083.                         if (fDoRightName) DrawName( r1, kNucBorder, drawer->GetName(row));        
  1084.                         }    
  1085.                     }
  1086.                 }
  1087.                 
  1088.             else if (col < fBasesPerLine+2) {
  1089.                 r.right= r.left + fSeqWidth;
  1090.                 ncols= fBasesPerLine; //stopitem - startitem;
  1091.                 (void) Nlm_SectRect( &r, &viewr, &r1);
  1092.                 RectRgn( cliprgn, &r1);  
  1093.                 Nlm_SectRgn( cliprgn, Nlm_updateRgn, cliprgn);
  1094.                 if ( !Nlm_EmptyRgn( cliprgn)) {
  1095.                     r1= r;
  1096.                     //Nlm_ClipRgn(cliprgn);
  1097.                     //drawer->fItemrow= itemrow - fTopPerparag;// so we know which seq line in array
  1098.                     drawer->Clip( r1, row, startitem, stopitem, viewr, cliprgn);
  1099.                     drawer->Draw( r1, row, col-2, startitem, stopitem);
  1100.                     }
  1101.                 }
  1102.         
  1103.           col += ncols;
  1104.             r.left= r.right;
  1105.             if (fWidths) r.right += fWidths[col];
  1106.             else r.right += fItemWidth;
  1107.             }
  1108.         }
  1109.     //Nlm_ClipRgn(Nlm_updateRgn);
  1110.     fColsDrawn= col - GetLeft();
  1111.     Nlm_ResetClip();
  1112.     Nlm_DestroyRgn(cliprgn);
  1113. }
  1114.  
  1115.  
  1116. void DSeqPrintView::WriteTo(DFile* aFile)
  1117. {
  1118.     if (aFile) {
  1119.         long irow, nrows;
  1120.         fFile= aFile;
  1121.         fFile->Open("a");
  1122.         nrows= GetMaxRows();  
  1123.         for (irow=0; irow<nrows; irow++) WriteRow( irow);
  1124.         fFile->Close();
  1125.         }
  1126. }
  1127.  
  1128. void DSeqPrintView::WriteRow(long row)
  1129. {
  1130.     long             itemrow, seqline, startitem, stopitem;
  1131.     long         col, ncols;
  1132.     DDrawMapRow * drawer;
  1133.     char * newline, * atline;
  1134.     
  1135.     IndexFromRow( row, itemrow, seqline, startitem, stopitem);
  1136.     drawer= (DDrawMapRow*) fDrawRowList->At(itemrow);
  1137.     if (!drawer) return;
  1138.     drawer->fItemrow= itemrow - fTopPerparag;// so we know which seq line in array
  1139.  
  1140.     atline= (char*) drawer->Write( row, 0, startitem, stopitem);
  1141.     while (atline) {
  1142.         newline= StrChr(atline, '\n');
  1143.         if (newline) *newline++= 0; // risky: (const char*) drawer->Write()
  1144.         
  1145.         for (col=0, ncols=1; col<fMaxCols; col += ncols) {
  1146.             if (col < 2 || col > fBasesPerLine+1) {
  1147.                         // do name & index borders
  1148.                 ncols= 1;
  1149.                 if (col == 0) {
  1150.                     if (fDoLeftName || drawer->DoLeftName()) WriteName(  0, drawer->GetName(row));
  1151.                     }
  1152.                 else if (col == 1) {
  1153.                     if (fDoLeftIndex) WriteSideIndex( drawer->GetIndex(startitem), kNucBorder);
  1154.                     }
  1155.                 else if (col == fBasesPerLine+2) {
  1156.                     if (fDoRightIndex) WriteSideIndex(  drawer->GetIndex(stopitem), 0);
  1157.                     }
  1158.                 else if (col == fBasesPerLine+3) {
  1159.                     if (fDoRightName) WriteName(  kNucBorder, drawer->GetName(row));        
  1160.                     }    
  1161.                 }
  1162.             else {
  1163.                 ncols= fBasesPerLine; 
  1164.                 fFile->WriteLine( " ", false);
  1165.                 fFile->WriteLine( atline, false);
  1166.                 }
  1167.             }
  1168.             
  1169.         atline= newline;
  1170.         fFile->WriteLine("\n");
  1171.         }
  1172. }
  1173.  
  1174.  
  1175.  
  1176.  
  1177.  
  1178.  
  1179.  
  1180.  
  1181.  
  1182. // class DSeqPrintDoc
  1183.  
  1184.  
  1185. Nlm_RecT DSeqPrintDoc::fgPrWinRect = { 0, 0, 0, 0 };
  1186.  
  1187. DSeqPrintDoc::DSeqPrintDoc( long id, DSeqDoc* itsDoc, DSeqList* itsSeqList, long firstbase, long nbases) :
  1188.         DWindow( kSeqPrintDoc, gApplication),
  1189.         fView(NULL),  
  1190.         fSeqList(itsSeqList),
  1191.         fFirstBase(firstbase), fNbases(nbases),
  1192.         //fHeadline(NULL), fFormatPop(NULL),
  1193.         //fLockButton(NULL), fColorButton(NULL), fMonoButton(NULL),
  1194.         fColorCheck(NULL), fLockCheck(NULL), 
  1195.         fUseColor(itsDoc->fUseColor)
  1196. { 
  1197.     short width= -1, height= -1, left= -10, top= -20; // default window loc
  1198.     if (id != 0) fId= id;
  1199.     
  1200.     //gTextFont = Nlm_GetFont( "Courier", 10, false, false, false, "Fixed");
  1201.     //if (gTextFont == NULL) gTextFont= Nlm_programFont;
  1202.  
  1203.         // testing reduced view
  1204.     if (gKeys->shift()) gBaseCharWidth= 1;    else gBaseCharWidth= 12; 
  1205.  
  1206.     if (!Nlm_EmptyRect(&fgPrWinRect))  {
  1207.         left= MAX(20,fgPrWinRect.left);
  1208.         top = MAX(40,fgPrWinRect.top);
  1209.         }
  1210.     
  1211.     char * winname= NULL;
  1212.     this->InitWindow( document, width, height, left, top); //, winname); 
  1213.  
  1214.     DSequence * aSeq;
  1215.     char title[256];
  1216.     if (!fSeqList) {
  1217.         fSeqList= new DSeqList();  
  1218.         fSeqList->AddNewSeq();    // install 1 blank seq for new doc
  1219.         aSeq= NULL;
  1220.         }
  1221.     else {
  1222.       aSeq= (DSequence*) fSeqList->At(0);
  1223.         }
  1224.     if (aSeq)  
  1225.         StrCpy(title, aSeq->Name());
  1226.     else
  1227.         itsDoc->GetTitle( title, sizeof(title)); 
  1228.     DFileManager::ReplaceSuffix( title, sizeof(title), ".Print");
  1229.     SetTitle( title);
  1230. }
  1231.  
  1232.  
  1233. DSeqPrintDoc::~DSeqPrintDoc()
  1234. {
  1235.     if (fSeqList) { 
  1236.         // we don't own DSeq objects in this list !!
  1237.         //fSeqList->FreeAllObjects(); 
  1238.         fSeqList->suicide(); 
  1239.         }
  1240. }
  1241.  
  1242.  
  1243. void DSeqPrintDoc::MakeGlobalsCurrent()
  1244. {
  1245.     ViewRect( fViewrect); // get current rect...
  1246.     if (!Nlm_EmptyRect(&fViewrect)) fgPrWinRect= fViewrect;  
  1247.     //fgUseColor= fColorCheck->GetStatus();
  1248. }
  1249.  
  1250. void DSeqPrintDoc::Close()
  1251. {
  1252.     MakeGlobalsCurrent();
  1253.     DWindow::Close();
  1254. }
  1255.  
  1256. void DSeqPrintDoc::ResizeWin()
  1257. {
  1258.     DWindow::ResizeWin();
  1259.     MakeGlobalsCurrent();
  1260. }
  1261.  
  1262.  
  1263. // static
  1264. void DSeqPrintDoc::GetGlobals()
  1265. {
  1266.  
  1267.     //char* onoffs= (fgUseColor) ? "1" : "0";
  1268.     //fgUseColor= gApplication->GetPrefVal( "fgUseColor", "windows", onoffs);
  1269.     {
  1270.     char* srect = gApplication->GetPref( "fgPrWinRect", "windows", "30 40 450 220");
  1271. #if 1
  1272.         // sscanf is failing on Mac/codewar !! used to work
  1273.     if (srect) {
  1274.         char* cp= srect;
  1275.         while (*cp && isspace(*cp)) cp++;
  1276.         fgPrWinRect.left= atoi( cp);
  1277.         
  1278.         while (*cp && !isspace(*cp)) cp++;
  1279.         while (*cp && isspace(*cp)) cp++;
  1280.         fgPrWinRect.top= atoi( cp);
  1281.         
  1282.         while (*cp && !isspace(*cp)) cp++;
  1283.         while (*cp && isspace(*cp)) cp++;
  1284.         fgPrWinRect.right= atoi( cp);
  1285.         
  1286.         while (*cp && !isspace(*cp)) cp++;
  1287.         while (*cp && isspace(*cp)) cp++;
  1288.         fgPrWinRect.bottom= atoi( cp);
  1289.         }
  1290. #else
  1291.         if (srect) sscanf( srect, "%d%d%d%d", &fgPrWinRect.left, &fgPrWinRect.top, 
  1292.                                                 &fgPrWinRect.right, &fgPrWinRect.bottom);
  1293. #endif
  1294.         Nlm_MemFree(srect);
  1295.     }
  1296. }
  1297.  
  1298. // static
  1299. void DSeqPrintDoc::SaveGlobals()
  1300. {
  1301.     //gApplication->SetPref( (int) fgUseColor, "fgUseColor","windows");
  1302.     if (!Nlm_EmptyRect(&fgPrWinRect)) {
  1303.         char  srect[128];
  1304.         sprintf( srect, "%d %d %d %d", fgPrWinRect.left, fgPrWinRect.top, 
  1305.                                                         fgPrWinRect.right, fgPrWinRect.bottom);
  1306.         gApplication->SetPref( srect, "fgPrWinRect", "windows");
  1307.         }
  1308. }
  1309.  
  1310.  
  1311. void DSeqPrintDoc::Open()
  1312. {
  1313.     DView*     super;
  1314.     short width, height;
  1315.     Nlm_PoinT        nps;
  1316.     
  1317.     //if (!fSeqList) fSeqList= new DSeqList();
  1318.     if (!fView) {
  1319.         super= this;
  1320.     
  1321.         width= 450; height= 350;
  1322.         super->GetNextPosition( &nps);
  1323.         width = MAX( 40, fgPrWinRect.right - fgPrWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  1324.         height= MAX( 60, fgPrWinRect.bottom - fgPrWinRect.top) - Nlm_hScrollBarHeight - nps.y;   
  1325.         fView= new DSeqPrintView(0,super,this,fSeqList,fFirstBase,fNbases,width,height);
  1326.         }
  1327.  
  1328.     fSaveHandler= this;  
  1329.     fPrintHandler= this;
  1330.     
  1331.     this->Select(); // for motif
  1332.     this->CalcWindowSize();
  1333.     fView->GetReadyToShow();
  1334.     
  1335.     DWindow::Open();
  1336. }
  1337.  
  1338.  
  1339.  
  1340.  
  1341. void DSeqPrintDoc::WriteTo(DFile* aFile)  
  1342. {
  1343.         // offer user choice of Text or PICT (or other? - PS) output
  1344.         // need popup choice in save-as dialog...
  1345.         
  1346.     short outform= DSeqPrintPrefs::gOutFormat;
  1347.     if (gKeys->shift()) {
  1348.         if (outform == DSeqPrintPrefs::cOutText) outform= DSeqPrintPrefs::cOutPICT;
  1349.         else outform= DSeqPrintPrefs::cOutText; 
  1350.         }
  1351.     switch (outform) {
  1352.         case DSeqPrintPrefs::cOutPICT:
  1353.             fView->WriteToPICT( aFile);
  1354.             break;
  1355.         case DSeqPrintPrefs::cOutText:
  1356.         default:
  1357.             fView->WriteTo( aFile); 
  1358.             break;
  1359.         }
  1360. }
  1361.         
  1362.  
  1363.  
  1364. void DSeqPrintDoc::Print()  
  1365. {
  1366.     fView->Print();
  1367. }
  1368.  
  1369.  
  1370.  
  1371.  
  1372.  
  1373.  
  1374.  
  1375.  
  1376.  
  1377.  
  1378.  
  1379.  
  1380. // class DAlnPrintView
  1381.  
  1382.  
  1383. DAlnPrintView::DAlnPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  1384.                                  DSeqList* itsSeqList, long firstbase, long nbases, long pixwidth, long pixheight):
  1385.         DSeqPrintView( id, itsSuper, itsDocument, itsSeqList, firstbase, nbases, pixwidth, pixheight)
  1386. { 
  1387.     fSeqLinesPerParag= fSeqList->GetSize();
  1388. }
  1389.  
  1390. // class DAlnPrintDoc
  1391.  
  1392. DAlnPrintDoc::DAlnPrintDoc( long id, DSeqDoc* itsDoc, DSeqList* itsSeqList, long firstbase, long nbases) :
  1393.     DSeqPrintDoc( id, itsDoc, itsSeqList, firstbase, nbases)
  1394. {
  1395.  
  1396.     short width= 450, height= 350;
  1397.     //super->GetNextPosition( &nps);
  1398.     //width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  1399.     //height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y;   
  1400.     fView= new DAlnPrintView(0,this,this,fSeqList,fFirstBase,fNbases,width,height);
  1401.  
  1402.     char title[256];
  1403.     itsDoc->GetTitle( title, sizeof(title)); 
  1404.     DFileManager::ReplaceSuffix( title, sizeof(title), ".Print");
  1405.     SetTitle( title);
  1406. }
  1407.  
  1408.  
  1409.  
  1410.  
  1411.  
  1412.  
  1413.  
  1414.  
  1415.  
  1416. //class DSeqPrintPrefs : public DWindow 
  1417.  
  1418.  
  1419.  
  1420. DSeqPrintPrefs::DSeqPrintPrefs() :
  1421.     DWindow( 0, NULL, DWindow::fixed, -10, -10, -50, -20, "SeqPrint prefs", kDontFreeOnClose),
  1422.     fNameFontMenu(NULL), fBaseFontMenu(NULL),  fIndexFontMenu(NULL),
  1423.     fNameStyleMenu(NULL), fBaseStyleMenu(NULL),  fIndexStyleMenu(NULL),
  1424.     fNameSizeSw(NULL), fBaseSizeSw(NULL),  fIndexSizeSw(NULL),
  1425.     fREMinCuts(NULL),  fREMaxCuts(NULL), fBasePerLine(NULL),
  1426.     fNeedSave(false)
  1427. {    
  1428. }
  1429.  
  1430. DSeqPrintPrefs::~DSeqPrintPrefs()
  1431. {
  1432. }
  1433.  
  1434.  
  1435. class DOutFormatPopup : public DPopupList
  1436. {
  1437. public:
  1438.     DOutFormatPopup(long id, DView* superior, short defaultFormat);
  1439.     virtual short GetValue() {
  1440.          return  DSeqPrintPrefs::cOutText + DPopupList::GetValue() - 1;
  1441.         }
  1442. };
  1443.  
  1444. DOutFormatPopup::DOutFormatPopup(long id, DView* superior, short defaultFormat) :
  1445.             DPopupList(id,superior,true)
  1446. {
  1447.     this->AddItem( "Text");
  1448.     this->AddItem( "PICT");
  1449.     this->SetValue(defaultFormat - DSeqPrintPrefs::cOutText + 1);
  1450. }
  1451.  
  1452.  
  1453. inline Nlm_FonT GetAFont( char* fname, short fsize, short fstyle)
  1454. {
  1455.     if (StrICmp(fname,"System")==0) return Nlm_systemFont;
  1456.     else if (StrICmp(fname,"Program")==0) return Nlm_programFont;
  1457.     else return Nlm_GetFont( fname, fsize, 
  1458.              fstyle & kBold, fstyle & kItalic, fstyle & kUnderline, NULL);
  1459. }
  1460.  
  1461. // static
  1462. void DSeqPrintPrefs::InitGlobals() 
  1463. { 
  1464.  
  1465.     gNameFontName= gApplication->GetPref( "gNameFontName", "fonts", gNameFontName);
  1466.     gNameFontSize= gApplication->GetPrefVal( "gNameFontSize", "fonts", "10");
  1467.     gNameStyle= gApplication->GetPrefVal( "gNameStyle", "fonts", "0");
  1468.     gNameFont= ::GetAFont(gNameFontName,gNameFontSize, gNameStyle);
  1469.  
  1470.     gBaseFontName= gApplication->GetPref( "gBaseFontName", "fonts", gBaseFontName);
  1471.     gBaseFontSize= gApplication->GetPrefVal( "gBaseFontSize", "fonts", "10");
  1472.     gBaseStyle= gApplication->GetPrefVal( "gBaseStyle", "fonts", "0");
  1473.     gBaseFont= ::GetAFont(gBaseFontName,gBaseFontSize, gBaseStyle);
  1474.  
  1475.     gIndexFontName= gApplication->GetPref( "gIndexFontName", "fonts", gIndexFontName);
  1476.     gIndexFontSize= gApplication->GetPrefVal( "gIndexFontSize", "fonts", "9");
  1477.     gIndexStyle= gApplication->GetPrefVal( "gIndexStyle", "fonts", "0");
  1478.     gIndexFont= ::GetAFont(gIndexFontName,gIndexFontSize, gIndexStyle);
  1479.     
  1480.     gNameLeft= gApplication->GetPrefVal( "gNameLeft", "seqprint","0");
  1481.     gNameRight= gApplication->GetPrefVal( "gNameRight", "seqprint","1");
  1482.     gIndexLeft= gApplication->GetPrefVal( "gIndexLeft", "seqprint","1");
  1483.     gIndexRight= gApplication->GetPrefVal( "gIndexRight", "seqprint","0");
  1484.     gIndexTop= gApplication->GetPrefVal( "gIndexTop", "seqprint","1");
  1485.     gColored= gApplication->GetPrefVal( "gColored", "seqprint","1");
  1486.     gBasesPerLine= gApplication->GetPrefVal( "gBasesPerLine", "seqprint","60");
  1487.     short outform= gApplication->GetPrefVal( "gOutFormat", "seqprint","0");
  1488.   if (outform) gOutFormat= outform;
  1489.   
  1490.     gShowComplement= gApplication->GetPrefVal( "gShowComplement", "seqprint","1");
  1491.     gThreeLetAA= gApplication->GetPrefVal( "gThreeLetAA", "seqprint","0");
  1492.     gOnlyORF= gApplication->GetPrefVal( "gOnlyORF", "seqprint","0");
  1493.     gShowAA1= gApplication->GetPrefVal( "gShowAA1", "seqprint","0");
  1494.     gShowAA2= gApplication->GetPrefVal( "gShowAA2", "seqprint","0");
  1495.     gShowAA3= gApplication->GetPrefVal( "gShowAA3", "seqprint","0");
  1496.     gShowCompAA1= gApplication->GetPrefVal( "gShowCompAA1", "seqprint","0");
  1497.     gShowCompAA2= gApplication->GetPrefVal( "gShowCompAA2", "seqprint","0");
  1498.     gShowCompAA3= gApplication->GetPrefVal( "gShowCompAA3", "seqprint","0");
  1499.  
  1500.     gShowAllZymes= gApplication->GetPrefVal( "gShowAllZymes", "remap","0");
  1501.     gShowCutpoints= gApplication->GetPrefVal( "gShowCutpoints", "remap","0");
  1502.     gShowNoncutters= gApplication->GetPrefVal( "gShowNoncutters", "remap","0");
  1503.     gShowExcludedCutters= gApplication->GetPrefVal( "gShowExcludedCutters", "remap","0");
  1504.  
  1505.     gREMinCuts= gApplication->GetPrefVal( "gREMinCuts", "remap","1");
  1506.     gREMaxCuts= gApplication->GetPrefVal( "gREMaxCuts", "remap","999");
  1507.  
  1508. #if 0
  1509.     {
  1510.     char* srect = gApplication->GetPref( "gSeqPrintDocRect", "windows", "20 20 450 220");
  1511.         // sscanf is failing on Mac/codewar !? used to work
  1512.     if (srect) {
  1513.         char* cp= srect;
  1514.         while (*cp && isspace(*cp)) cp++;
  1515.         gSeqPrintDocRect.left= atoi( cp);
  1516.         
  1517.         while (*cp && !isspace(*cp)) cp++;
  1518.         while (*cp && isspace(*cp)) cp++;
  1519.         gSeqPrintDocRect.top= atoi( cp);
  1520.         
  1521.         while (*cp && !isspace(*cp)) cp++;
  1522.         while (*cp && isspace(*cp)) cp++;
  1523.         gSeqPrintDocRect.right= atoi( cp);
  1524.         
  1525.         while (*cp && !isspace(*cp)) cp++;
  1526.         while (*cp && isspace(*cp)) cp++;
  1527.         gSeqPrintDocRect.bottom= atoi( cp);
  1528.         }
  1529.     MemFree(srect);
  1530.     }    
  1531. #endif
  1532.  
  1533. }
  1534.  
  1535.  
  1536. //static
  1537. void DSeqPrintPrefs::SaveGlobals() 
  1538. {
  1539.     gApplication->SetPref( gNameFontName, "gNameFontName", "fonts");
  1540.     gApplication->SetPref( gNameFontSize, "gNameFontSize", "fonts");
  1541.     gApplication->SetPref( gNameStyle, "gNameStyle", "fonts");
  1542.     gApplication->SetPref( gBaseFontName, "gBaseFontName", "fonts");
  1543.     gApplication->SetPref( gBaseFontSize, "gBaseFontSize", "fonts");
  1544.     gApplication->SetPref( gBaseStyle, "gBaseStyle", "fonts");
  1545.     gApplication->SetPref( gIndexFontName, "gIndexFontName", "fonts");
  1546.     gApplication->SetPref( gIndexFontSize, "gIndexFontSize", "fonts");
  1547.     gApplication->SetPref( gIndexStyle, "gIndexStyle", "fonts");
  1548.     
  1549.     gApplication->SetPref( gNameLeft, "gNameLeft", "seqprint");
  1550.     gApplication->SetPref( gNameRight, "gNameRight", "seqprint");
  1551.     gApplication->SetPref( gIndexLeft, "gIndexLeft", "seqprint");
  1552.     gApplication->SetPref( gIndexRight, "gIndexRight", "seqprint");
  1553.     gApplication->SetPref( gIndexTop, "gIndexTop", "seqprint");
  1554.     gApplication->SetPref( gColored, "gColored", "seqprint");
  1555.     gApplication->SetPref( gBasesPerLine, "gBasesPerLine", "seqprint");
  1556.     gApplication->SetPref( gOutFormat, "gOutFormat", "seqprint");
  1557.     
  1558. // restrict map
  1559.     gApplication->SetPref( gShowComplement, "gShowComplement", "seqprint");
  1560.     gApplication->SetPref( gThreeLetAA, "gThreeLetAA", "seqprint");
  1561.     gApplication->SetPref( gOnlyORF, "gOnlyORF", "seqprint");
  1562.     
  1563.     gApplication->SetPref( gShowAA1, "gShowAA1", "seqprint");
  1564.     gApplication->SetPref( gShowAA2, "gShowAA2", "seqprint");
  1565.     gApplication->SetPref( gShowAA3, "gShowAA3", "seqprint");
  1566.     gApplication->SetPref( gShowCompAA1, "gShowCompAA1", "seqprint");
  1567.     gApplication->SetPref( gShowCompAA2, "gShowCompAA2", "seqprint");
  1568.     gApplication->SetPref( gShowCompAA3, "gShowCompAA3", "seqprint");
  1569.  
  1570. // rest. map tables
  1571.     gApplication->SetPref( gShowAllZymes, "gShowAllZymes", "remap");
  1572.     gApplication->SetPref( gShowCutpoints, "gShowCutpoints", "remap");
  1573.     gApplication->SetPref( gShowNoncutters, "gShowNoncutters", "remap");
  1574.     gApplication->SetPref( gShowExcludedCutters, "gShowExcludedCutters", "remap");
  1575.     gApplication->SetPref( gREMinCuts, "gREMinCuts", "remap");
  1576.     gApplication->SetPref( gREMaxCuts, "gREMaxCuts", "remap");
  1577.  
  1578. }
  1579.  
  1580.  
  1581.  
  1582.  
  1583. void DSeqPrintPrefs::NewFontCluster(char* title, DView* mainview,
  1584.                     DPopupMenu*& mfont, DPopupMenu*& mstyle, DSwitchBox*& swsize,
  1585.                     char* fontname, short fontstyle, short fontsize )
  1586. {    
  1587.         // Name style -- font, font size, font style
  1588.     DPopupMenu* popm;
  1589.     DSwitchBox* sw;
  1590.     DPrompt* pr;
  1591.     DView* super;
  1592.     
  1593.     super= mainview;
  1594.     super->NextSubviewBelowLeft();
  1595.  
  1596.     DCluster* maincluster= new DCluster( 0, super, 30, 10, true, NULL); //false, title);
  1597.     super= maincluster;
  1598.  
  1599.     popm= new DPopupMenu( 0, (Nlm_GrouP)super->GetNlmObject(), "Font  ");
  1600.     mfont= popm;
  1601.     popm->AddFonts();
  1602.     popm->SetFontChoice( fontname); 
  1603.     //super->NextSubviewToRight();
  1604.  
  1605.     popm= new DPopupMenu( 0, (Nlm_GrouP)super->GetNlmObject(), "Style  ");
  1606.     mstyle= popm;
  1607.     popm->AddItem( kStylePlain, "Plain", true);
  1608.     popm->AddItem( kStyleItalic, "Italic", true);
  1609.     popm->AddItem( kStyleBold, "Bold", true);
  1610.     popm->AddItem( kStyleUnderline, "Underline", true);
  1611.     popm->SetItemStatus( kStylePlain, fontstyle==0);
  1612.     popm->SetItemStatus( kStyleItalic, fontstyle & kItalic);
  1613.     popm->SetItemStatus( kStyleBold, fontstyle & kBold);
  1614.     popm->SetItemStatus( kStyleUnderline, fontstyle & kUnderline);
  1615.     //super->NextSubviewToRight();
  1616.     
  1617.     DCluster* cluster= new DCluster(0, super, 30, 10, true, NULL);
  1618.     super= cluster;
  1619.     
  1620.     pr= new DPrompt( 0, super, "font size", 0, 0, Nlm_programFont);             
  1621.     //super->NextSubviewToRight();
  1622.     super->NextSubviewBelowLeft();
  1623.     sw = new DSwitchBox(0, super, true, true);
  1624.     swsize= sw;
  1625.     sw->SetValues(fontsize,99);
  1626.     //super->NextSubviewBelowLeft();
  1627.  
  1628.     super= mainview;
  1629.     super->NextSubviewBelowLeft();
  1630. }
  1631.  
  1632.  
  1633.  
  1634.  
  1635. void DSeqPrintPrefs::Initialize() 
  1636. { 
  1637.     DView* super;
  1638.     DPrompt* pr;
  1639.     DCheckBox* ck;
  1640.     DCluster* clu;
  1641.     char nums[128];    
  1642.     DPopupMenu* popm;
  1643.  
  1644.     super= this;
  1645.     clu= new DCluster( 0, super, 30, 10, false, "Bases");
  1646.     super= clu;
  1647.  
  1648.     NewFontCluster( "Base style", super, fBaseFontMenu, fBaseStyleMenu, fBaseSizeSw,
  1649.                             gBaseFontName, gBaseStyle, gBaseFontSize);
  1650.  
  1651.     ck= new DCheckBox(cColored, super, "Color ");
  1652.     ck->SetStatus(gColored);
  1653.     super->NextSubviewToRight();
  1654.     
  1655.     sprintf( nums, "%d", gBasesPerLine);
  1656.     fBasePerLine= new DEditText( 0, super, nums, 4, Nlm_programFont); 
  1657.     this->SetEditText( fBasePerLine);
  1658.     super->NextSubviewToRight();
  1659.     pr= new DPrompt( 0, super, "bases/line", 0, 0, Nlm_programFont);             
  1660.  
  1661.     super = this;
  1662.     //super->NextSubviewToRight();
  1663.     //super->NextSubviewBelowLeft();
  1664.  
  1665.     clu= new DCluster( 0, super, 30, 10, false, "Indices");
  1666.     super= clu;
  1667.  
  1668.     NewFontCluster( "Index style", super, fIndexFontMenu, fIndexStyleMenu, fIndexSizeSw,
  1669.                             gIndexFontName, gIndexStyle, gIndexFontSize);
  1670.  
  1671.     ck= new DCheckBox(cIndexLeft, super, "Left");
  1672.     ck->SetStatus(gIndexLeft);
  1673.     ck= new DCheckBox(cIndexRight, super, "Right");
  1674.     ck->SetStatus(gIndexRight);
  1675.     ck= new DCheckBox(cIndexTop, super, "Top");
  1676.     ck->SetStatus(gIndexTop);
  1677.  
  1678.     super = this;
  1679.     //super->NextSubviewToRight();
  1680.     //super->NextSubviewBelowLeft();
  1681.  
  1682.     clu= new DCluster( 0, super, 30, 10, false, "Names");
  1683.     super= clu;
  1684.  
  1685.     NewFontCluster( "Name style", super, fNameFontMenu, fNameStyleMenu, fNameSizeSw,
  1686.                             gNameFontName, gNameStyle, gNameFontSize);
  1687.  
  1688.     ck= new DCheckBox(cNameLeft, super, "Left");
  1689.     ck->SetStatus(gNameLeft);
  1690.     ck= new DCheckBox(cNameRight, super, "Right");
  1691.     ck->SetStatus(gNameRight);
  1692.     
  1693.     super = this;
  1694.     //super->NextSubviewToRight();
  1695.     //super->NextSubviewBelowLeft();
  1696.  
  1697.     clu= new DCluster( 0, super, 0, 0, true);
  1698.     super= clu;
  1699.     pr= new DPrompt(0,super,"File format:",0, 0, Nlm_programFont);
  1700.     super->NextSubviewToRight();
  1701.     DOutFormatPopup* apop = new DOutFormatPopup( cOutText, super, gOutFormat);
  1702.     super = this;
  1703.     super->NextSubviewBelowLeft();
  1704.  
  1705.     //super->NextSubviewToRight();
  1706.  
  1707. #if 1        
  1708.  
  1709.                 // turn this into 2nd dialog window...
  1710.                 
  1711.     clu= new DCluster( 0, super, 30, 10, false, "Restriction Maps");
  1712.     super= clu;
  1713.  
  1714.     ck= new DCheckBox(cShowComplement, super, "Show Complement");
  1715.     ck->SetStatus(gShowComplement);
  1716.     super->NextSubviewBelowLeft();
  1717.     
  1718.     DCluster* pclu= new DCluster( 0, super, 30, 10, false, "Protein translate frame");
  1719.     super= pclu;
  1720.     pr= new DPrompt( 0, super, " sequence", 0, 0, Nlm_programFont);             
  1721.     super->NextSubviewToRight();
  1722.     ck= new DCheckBox(cShowAA1, super, "1st");
  1723.     ck->SetStatus(gShowAA1);
  1724.     super->NextSubviewToRight();
  1725.     ck= new DCheckBox(cShowAA2, super, "2nd");
  1726.     ck->SetStatus(gShowAA2);
  1727.     super->NextSubviewToRight();
  1728.     ck= new DCheckBox(cShowAA3, super, "3rd");
  1729.     ck->SetStatus(gShowAA3);
  1730.     super->NextSubviewBelowLeft();
  1731.  
  1732.     pr= new DPrompt( 0, super, "complement", 0, 0, Nlm_programFont);             
  1733.     super->NextSubviewToRight();
  1734.     ck= new DCheckBox(cShowCompAA1, super, "1st");
  1735.     ck->SetStatus(gShowCompAA1);
  1736.     super->NextSubviewToRight();
  1737.     ck= new DCheckBox(cShowCompAA2, super, "2nd");
  1738.     ck->SetStatus(gShowCompAA2);
  1739.     super->NextSubviewToRight();
  1740.     ck= new DCheckBox(cShowCompAA3, super, "3rd");
  1741.     ck->SetStatus(gShowCompAA3);
  1742.  
  1743.     super->NextSubviewBelowLeft();
  1744.     ck= new DCheckBox(cThreeLetAA, super, "3-letter code");
  1745.     ck->SetStatus(gThreeLetAA);
  1746.     super->NextSubviewToRight();
  1747.     ck= new DCheckBox(cOnlyORF, super, "ORFs only");
  1748.     ck->SetStatus(gOnlyORF);
  1749.     super= clu;
  1750.     super->NextSubviewBelowLeft();
  1751.  
  1752.     DCluster* rclu= new DCluster( 0, super, 30, 10, false, "Restriction enzymes");
  1753.     super= rclu;
  1754.  
  1755.     pr= new DPrompt( 0, super, "Min. cuts", 0, 0, Nlm_programFont);             
  1756.     super->NextSubviewToRight();
  1757.     sprintf( nums, "%d", gREMinCuts);
  1758.     fREMinCuts= new DEditText( 0, super, nums, 4, Nlm_programFont); 
  1759.     this->SetEditText( fREMinCuts);
  1760.     pr= new DPrompt( 0, super, "Max. cuts", 0, 0, Nlm_programFont);             
  1761.     super->NextSubviewToRight();
  1762.     sprintf( nums, "%d", gREMaxCuts);
  1763.     fREMaxCuts= new DEditText( 0, super, nums, 4, Nlm_programFont); 
  1764.     super->NextSubviewBelowLeft();
  1765.  
  1766.     pr= new DPrompt( 0, super, "Tables", 0, 0, Nlm_programFont);             
  1767.     super->NextSubviewToRight();
  1768.     ck= new DCheckBox(cShowCutpoints, super, "Cutpoints");
  1769.     ck->SetStatus(gShowCutpoints);
  1770.     ck= new DCheckBox(cShowAllZymes, super, "All zymes");
  1771.     ck->SetStatus(gShowAllZymes);
  1772.     super->NextSubviewBelowLeft();
  1773.     ck= new DCheckBox(cShowNoncutters, super, "Noncutters");
  1774.     ck->SetStatus(gShowNoncutters);
  1775.     ck= new DCheckBox(cShowExcludedCutters, super, "Excluded cutters");
  1776.     ck->SetStatus(gShowExcludedCutters);
  1777.  
  1778.     super= clu;
  1779.  
  1780.     super= this;
  1781. #endif
  1782.  
  1783.     this->AddOkayCancelButtons();
  1784.     
  1785. }
  1786.  
  1787.  
  1788. void DSeqPrintPrefs::OkayAction() 
  1789. { 
  1790.     short             aSize, aStyle;
  1791.     char            name[256], *nums;
  1792.     DMenu     *    aFontMenu, * aStyleMenu;
  1793.     Nlm_FonT    aFont;
  1794.     
  1795.     if (fREMinCuts) {
  1796.         nums= fREMinCuts->GetTitle(name, sizeof(name));
  1797.         gREMinCuts= atol(nums);
  1798.         }
  1799.     if (fREMaxCuts) {
  1800.         nums= fREMaxCuts->GetTitle(name, sizeof(name));
  1801.         gREMaxCuts= atol(nums);
  1802.         }
  1803.     if (fBasePerLine) {
  1804.         nums= fBasePerLine->GetTitle(name, sizeof(name));
  1805.         gBasesPerLine= atol(nums);
  1806.         }
  1807.  
  1808.         
  1809.     for (short imenu= 0; imenu<3; imenu++) {
  1810.         
  1811.         switch (imenu) {
  1812.           case 0:
  1813.                 aFontMenu= fNameFontMenu; 
  1814.                 aStyleMenu= fNameStyleMenu; 
  1815.                 aSize= fNameSizeSw->GetValue();// aSize= gNameFontSize;
  1816.               break;
  1817.           case 1:
  1818.                 aFontMenu= fBaseFontMenu; 
  1819.                 aStyleMenu= fBaseStyleMenu; 
  1820.                 aSize= fBaseSizeSw->GetValue();// aSize= gBaseFontSize;
  1821.               break;
  1822.           case 2:
  1823.                 aFontMenu= fIndexFontMenu; 
  1824.                 aStyleMenu= fIndexStyleMenu; 
  1825.                 aSize= fIndexSizeSw->GetValue();// aSize= gIndexFontSize;
  1826.               break;
  1827.           }
  1828.             
  1829.         if (aFontMenu && aFontMenu->GetFontChoice(name, sizeof(name))) {
  1830.             aStyle= 0;
  1831. #ifdef WIN_MAC
  1832.             if (!aStyleMenu->GetItemStatus(kStylePlain)) {
  1833.                 if (aStyleMenu->GetItemStatus(kStyleItalic   )) aStyle |= kItalic;
  1834.                 if (aStyleMenu->GetItemStatus(kStyleBold     )) aStyle |= kBold;
  1835.                 if (aStyleMenu->GetItemStatus(kStyleUnderline)) aStyle |= kUnderline;
  1836.                 }
  1837. #else
  1838.              short item= Nlm_GetValue(((DPopupMenu*)aStyleMenu)->fPopup);
  1839.              // ^^ same as aStyleMenu->GetValue(); //??
  1840.              switch (item) {
  1841.                  case 1: aStyle= 0; break;
  1842.                  case 2: aStyle |= kItalic; break;
  1843.                  case 3: aStyle |= kBold; break;
  1844.                  case 4: aStyle |= kUnderline; break;
  1845.         }
  1846. #endif             
  1847.             if (StringCmp(name,"System")==0) aFont= Nlm_systemFont;
  1848.             else if (StringCmp(name,"Program")==0) aFont= Nlm_programFont;
  1849.             else aFont= Nlm_GetFont( name, aSize, aStyle & kBold, 
  1850.                                                     aStyle & kItalic, aStyle & kUnderline, NULL);
  1851.             
  1852.             switch (imenu) {
  1853.               case 0: 
  1854.               if (aSize != gNameFontSize || aStyle != gNameStyle || StringCmp(name,gNameFontName)!=0) {
  1855.                     if (gNameFontName) MemFree(gNameFontName);
  1856.                     gNameFontName= StrDup(name);
  1857.                     gNameFont= aFont;
  1858.                     gNameFontSize= aSize;
  1859.                     gNameStyle= aStyle;
  1860.                     fNeedSave= true;
  1861.                     }
  1862.                   break;
  1863.                   
  1864.               case 1: 
  1865.               if (aSize != gBaseFontSize || aStyle != gBaseStyle || StringCmp(name,gBaseFontName)!=0) {
  1866.                     if (gBaseFontName) MemFree(gBaseFontName);
  1867.                     gBaseFontName= StrDup(name);
  1868.                     gBaseFont= aFont;
  1869.                     gBaseFontSize= aSize;
  1870.                     gBaseStyle= aStyle;
  1871.                     fNeedSave= true;
  1872.                     }
  1873.                   break;
  1874.                   
  1875.               case 2: 
  1876.               if (aSize != gIndexFontSize || aStyle != gBaseStyle || StringCmp(name,gIndexFontName)!=0) {
  1877.                     if (gIndexFontName) MemFree(gIndexFontName);
  1878.                     gIndexFontName= StrDup(name);
  1879.                     gIndexFont= aFont;
  1880.                     gIndexFontSize= aSize;
  1881.                     gIndexStyle= aStyle;
  1882.                     fNeedSave= true;
  1883.                     }
  1884.                   break;
  1885.               }
  1886.               
  1887.             }
  1888.         }
  1889.     
  1890. #if 0
  1891. #if 1
  1892.     // CurrentWindow gets prefs dlog window, not one we want    
  1893.     //DSeqPrintDoc* awin= (DSeqPrintDoc*) gWindowManager->CurrentWindow();
  1894.     DList* wins= gWindowManager->GetWindowList();
  1895.     if (wins) {
  1896.         short last1= wins->GetSize() - 2;
  1897.         if (last1>0) {
  1898.             DSeqPrintDoc* awin= (DSeqPrintDoc*) wins->At(last1);
  1899.             if (awin && awin->Id() == DSeqPrintDoc::kSeqPrintDoc) {
  1900.                 awin->fView->Initialize();
  1901.                 awin->fView->GetReadyToShow();
  1902.                 awin->fView->Invalidate();
  1903.                 }
  1904.             }
  1905.         }
  1906. #else    
  1907.     DList* wins= gWindowManager->GetWindowList();
  1908.     if (wins) {
  1909.         long i, nwin= wins->GetSize();
  1910.         for (i= nwin-1; i>=0; i--) {
  1911.             DSeqPrintDoc* awin= (DSeqPrintDoc*) wins->At(i);
  1912.             if (awin && awin->Id() == DSeqPrintDoc::kSeqPrintDoc) {
  1913.                 awin->fView->Initialize();
  1914.                 awin->fView->GetReadyToShow();
  1915.                 awin->fView->Invalidate();
  1916.                 break; // do only 1st we find ...
  1917.                 }
  1918.             }
  1919.         }
  1920. #endif        
  1921. #endif
  1922.  
  1923. }
  1924.  
  1925.  
  1926.  
  1927. Boolean DSeqPrintPrefs::IsMyAction(DTaskMaster* action) 
  1928. {    
  1929.     DView* aview= (DView*) action;
  1930.     
  1931.     switch (action->Id()) {
  1932.  
  1933.         case cIndexLeft : gIndexLeft= aview->GetStatus(); break;
  1934.         case cIndexRight: gIndexRight= aview->GetStatus(); break;
  1935.         case cIndexTop  : gIndexTop= aview->GetStatus(); break;
  1936.         case cNameLeft    : gNameLeft= aview->GetStatus(); break;
  1937.         case cNameRight    : gNameRight= aview->GetStatus(); break;
  1938.         case cColored        : gColored= aview->GetStatus(); break;
  1939.  
  1940.         case cShowComplement: gShowComplement= aview->GetStatus(); break;
  1941.         case cThreeLetAA    : gThreeLetAA= aview->GetStatus(); break;
  1942.         case cOnlyORF    : gOnlyORF= aview->GetStatus(); break;
  1943.         case cShowAA1    : gShowAA1= aview->GetStatus(); break;
  1944.         case cShowAA2    : gShowAA2= aview->GetStatus(); break;
  1945.         case cShowAA3    : gShowAA3= aview->GetStatus(); break;
  1946.         case cShowCompAA1    : gShowCompAA1= aview->GetStatus(); break;
  1947.         case cShowCompAA2    : gShowCompAA2= aview->GetStatus(); break;
  1948.         case cShowCompAA3    : gShowCompAA3= aview->GetStatus(); break;
  1949.         case cShowCutpoints    : gShowCutpoints= aview->GetStatus(); break;
  1950.         case cShowAllZymes    : gShowAllZymes= aview->GetStatus(); break;
  1951.         case cShowNoncutters    : gShowNoncutters= aview->GetStatus(); break;
  1952.         case cShowExcludedCutters    : gShowExcludedCutters= aview->GetStatus(); break;
  1953.         case cOutText: gOutFormat= aview->GetValue(); break;
  1954.       
  1955.         default : return DWindow::IsMyAction(action);    
  1956.         }
  1957.         
  1958.     fNeedSave= true;
  1959.     return true;
  1960. }
  1961.  
  1962.  
  1963. void DSeqPrintPrefs::Open()
  1964. {
  1965.     DWindow::Open();
  1966. }
  1967.  
  1968. void DSeqPrintPrefs::Close()
  1969. {
  1970.     if (fNeedSave) {
  1971.         DSeqPrintPrefs::SaveGlobals();
  1972.         fNeedSave= false;
  1973.         }
  1974.     DWindow::Close();
  1975. }
  1976.  
  1977.  
  1978.  
  1979.     // global calling function
  1980. void SeqPrintPrefs(short id)
  1981. {
  1982.     switch (id) {
  1983.     
  1984.         case kSeqPrintPrefInit: 
  1985.             DSeqPrintPrefs::InitGlobals(); 
  1986.             break;
  1987.     
  1988.         case kSeqPrintPrefDialog:
  1989.             if (!gSeqPrintPrefs) {
  1990.                 gSeqPrintPrefs = new DSeqPrintPrefs();
  1991.                 gSeqPrintPrefs->Initialize();
  1992.                 }
  1993.             if (gSeqPrintPrefs && gSeqPrintPrefs->PoseModally()) ;
  1994.             break;
  1995.             
  1996.         case kAlnPrintPrefDialog:
  1997.         case kREMapPrefDialog:
  1998.             break;
  1999.     }
  2000.     
  2001. }
  2002.  
  2003.  
  2004.